home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 11 / Cream of the Crop 11-1.iso / games / ted5.zip / TED5-1.C < prev    next >
C/C++ Source or Header  |  1993-12-06  |  43KB  |  2,090 lines
  1. ////////////////////////////////////////////////////
  2. ////////////////////////////////////////////////////
  3. //
  4. // TED5-1
  5. //
  6. ////////////////////////////////////////////////////
  7. ////////////////////////////////////////////////////
  8. #include "ted5.h"
  9. #pragma hdrstop
  10.  
  11. void InputMap(char *lvlname,unsigned *levelw,unsigned *levelh,int exitok);
  12. void MNameOn(int x,int y,int i);
  13. void MNameOff(int x,int y,int i);
  14. void DnarOn(int x,int y);
  15. void DnarOff(int x,int y);
  16. void UparOn(int x,int y);
  17. void UparOff(int x,int y);
  18. void ExitOn(int x,int y);
  19. void ExitOff(int x,int y);
  20. void TInfoNon(int x,int y,int b);
  21. void TInfoNoff(int x,int y,int b);
  22. void TInfoMNon(int x,int y,int b);
  23. void TInfoMNoff(int x,int y,int b);
  24. void TIDoneOn(int x,int y);
  25. void TIDoneOff(int x,int y);
  26.  
  27.  
  28. ////////////////////////////////////////////////////
  29. //
  30. // SAVE the current map
  31. //
  32. ////////////////////////////////////////////////////
  33. void SaveMap(int delmap)
  34. {
  35.  memptr block;
  36.  long fsize,size,nsize,change;
  37.  MapHeaderStr TempHeader;
  38.  int i,XMStemp;
  39.  char string[100],TEDid[]=IDSTRING;
  40.  
  41.  
  42.  
  43.  RemoveUndoBuffers();
  44.  if (delmap)
  45.    {
  46.     LoadFile(mapname,(char huge *)&TempHeader,
  47.     MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
  48.     strcpy(string,"Deleting Map, '");
  49.     strcat(string,TempHeader.name);
  50.    }
  51.  else
  52.    {
  53.     strcpy(string,"Saving Map, '");
  54.     strcat(string,MapHeader.name);
  55.    }
  56.  
  57.  strcat(string,"'.");
  58.  ErrDialog(string,"");
  59.  
  60.  
  61.  BackupFile(mapheadname);
  62.  BackupFile(SM_loadname);
  63.  
  64.  
  65.  if (delmap || DirtyFlag)
  66.    {
  67.     //
  68.     // SAVE MAP FILE HEADER
  69.     //
  70.     if (delmap)
  71.       MapFileHeader->dataoffsets[whichmap]=-1;
  72.  
  73.     SaveFile(mapheadname,MK_FP(MapFileHeader,0),0,sizeof(MapFileHeaderStr));
  74.     fsize=sizeof(MapFileHeaderStr);
  75.  
  76.     //
  77.     // COMPRESS & SAVE TILEINFOS
  78.     //
  79.     MMAllocate(&block,tilenum);
  80.     for (i=0;i<numtplanes;i++)
  81.       {
  82.        MapFileHeader->tileinfooff[i]=fsize;
  83.        nsize=RLEBCompress(MK_FP(Tinfo[i],0),tilenum,MK_FP(block,0),MapFileHeader->RLEWtag);
  84.        MapFileHeader->tileinfolen[i]=nsize;
  85.        SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
  86.        fsize+=nsize;
  87.       }
  88.     MMFreePtr(&block);
  89.  
  90.     MMAllocate(&block,tilemnum);
  91.     for (i=0;i<numtmplanes;i++)
  92.       {
  93.        MapFileHeader->tileinfomoff[i]=fsize;
  94.        nsize=RLEBCompress(MK_FP(TMinfo[i],0),tilemnum,MK_FP(block,0),MapFileHeader->RLEWtag);
  95.        MapFileHeader->tileinfomlen[i]=nsize;
  96.        SaveFile(mapheadname,MK_FP(block,0),fsize,nsize);
  97.        fsize+=nsize;
  98.       }
  99.     MMFreePtr(&block);
  100.  
  101.     MapFileHeader->oldtilenum=tilenum;
  102.     MapFileHeader->oldtilemnum=tilemnum;
  103.  
  104.     SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
  105.     //
  106.     // SAVE ALREADY COMPRESSED MAPS
  107.     //
  108.  
  109.     //
  110.     // IF MAPS ARE IN XMS ALREADY, ALLOCATE A NEW BUFFER
  111.     // TO SHUFFLE ALREADY-COMPRESSED MAPS INTO
  112.     //
  113.     if (XMSmaps)
  114.       {
  115.        int planes;
  116.        long len=filelen(SM_loadname);
  117.  
  118.  
  119.        planes=(MapFileHeader->maptype&BPLANE>0)+
  120.           (MapFileHeader->maptype&FPLANE>0)+
  121.           (MapFileHeader->maptype&IPLANE>0);
  122.        len+=2L*mapwidth*mapheight*planes;
  123.  
  124.        if (1024L*XMSTotalFree()<len)
  125.      {
  126.       XMSFreeMem(XMSmaps);
  127.       XMSmaps=0;
  128.      }
  129.        else
  130.      XMStemp=XMSAllocate(len);
  131.       }
  132.  
  133.     //
  134.     // NOTE: I AM STORING "TED5" AT THE START OF THE FILE BECAUSE
  135.     // SAVING THE FILE AT OFFSET 0 WILL TRASH IT (I HAVE TO RE-SAVE THE HEADER!)
  136.     //
  137.     if (XMSmaps)
  138.       XMSmove(0,(long)&TEDid,XMStemp,0,strlen(TEDid));
  139.     else
  140.       SaveFile(SM_name,(char huge *)TEDid,0,strlen(TEDid));
  141.     fsize=strlen(TEDid);
  142.  
  143.     for (i=0;i<100;i++)
  144.     {
  145.      long oldoff;
  146.  
  147.      if (MapFileHeader->dataoffsets[i]==-1 || i==whichmap)
  148.        continue;
  149.  
  150.      oldoff=MapFileHeader->dataoffsets[i];
  151.  
  152.      if (XMSmaps)
  153.        XMSmove(XMSmaps,oldoff,0,(long)&TempHeader,sizeof(MapHeaderStr));
  154.      else
  155.        LoadFile(SM_loadname,(char huge *)&TempHeader,oldoff,sizeof(MapHeaderStr));
  156.  
  157.      strcpy(TempHeader.name,MapNames[i]);
  158.      MapFileHeader->dataoffsets[i]=fsize;
  159.      size=TempHeader.mapbkgndlen+TempHeader.mapfrgndlen+TempHeader.mapinfolen;
  160.      change=TempHeader.mapbkgndpl-fsize-sizeof(MapHeaderStr);
  161.      TempHeader.mapbkgndpl-=change;
  162.      TempHeader.mapfrgndpl-=change;
  163.      TempHeader.mapinfopl-=change;
  164.  
  165.      if (XMSmaps)
  166.        XMSmove(0,(long)&TempHeader,XMStemp,fsize,sizeof(MapHeaderStr));
  167.      else
  168.        SaveFile(SM_name,(char huge *)&TempHeader,fsize,sizeof(MapHeaderStr));
  169.      fsize+=sizeof(MapHeaderStr);
  170.  
  171.      if (XMSmaps)
  172.        {
  173.     XMSmove(XMSmaps,oldoff+sizeof(MapHeaderStr),XMStemp,fsize,size);
  174.     fsize+=size;
  175.     XMSmove(0,(long)"!ID!",XMStemp,fsize,4);
  176.     fsize+=4;
  177.        }
  178.      else
  179.        {
  180.     MMAllocate(&block,size);
  181.     LoadFile(SM_loadname,MK_FP(block,0),oldoff+sizeof(MapHeaderStr),size);
  182.     SaveFile(SM_name,MK_FP(block,0),fsize,size);
  183.     fsize+=size;
  184.     SaveFile(SM_name,"!ID!",fsize,4);
  185.     fsize+=4;
  186.     MMFreePtr(&block);
  187.        }
  188.     }
  189.  
  190.     //
  191.     // SAVE CURRENT MAP AT END OF FILE
  192.     //
  193.     if (!delmap)
  194.       {
  195.        MapFileHeader->dataoffsets[whichmap]=fsize;
  196.        MapFileHeader->datalengths[whichmap]=sizeof(MapHeaderStr);
  197.        if (XMSmaps)
  198.      XMSmove(0,(long)&MapHeader,XMStemp,fsize,sizeof(MapHeaderStr));
  199.        else
  200.      SaveFile(SM_name,(char huge *)&MapHeader,fsize,sizeof(MapHeaderStr));
  201.        fsize+=sizeof(MapHeaderStr);
  202.  
  203.        size=MapHeader.width*MapHeader.height*sizeof(int);
  204.        MMAllocate(&block,size);
  205.        if (MapFileHeader->maptype & BPLANE)
  206.      {
  207.       MapHeader.mapbkgndpl=fsize;
  208.       nsize=RLEWCompress(MK_FP(MapBkgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
  209.  
  210.       MapHeader.mapbkgndlen=nsize+2;
  211.  
  212.       if (XMSmaps)
  213.         XMSmove(0,(long)&size,XMStemp,fsize,2);
  214.       else
  215.         SaveFile(SM_name,(char huge *)&size,fsize,2);
  216.  
  217.       fsize+=2;
  218.  
  219.       if (XMSmaps)
  220.         XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
  221.       else
  222.         SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
  223.  
  224.       fsize+=nsize;
  225.      }
  226.        else
  227.      MapHeader.mapbkgndlen=0;
  228.  
  229.        if (MapFileHeader->maptype & FPLANE)
  230.      {
  231.       MapHeader.mapfrgndpl=fsize;
  232.       nsize=RLEWCompress(MK_FP(MapFrgnd,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
  233.  
  234.       MapHeader.mapfrgndlen=nsize+2;
  235.  
  236.       if (XMSmaps)
  237.         XMSmove(0,(long)&size,XMStemp,fsize,2);
  238.       else
  239.         SaveFile(SM_name,(char huge *)&size,fsize,2);
  240.  
  241.       fsize+=2;
  242.  
  243.       if (XMSmaps)
  244.         XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
  245.       else
  246.         SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
  247.  
  248.       fsize+=nsize;
  249.      }
  250.        else
  251.      MapHeader.mapfrgndlen=0;
  252.  
  253.        if (MapFileHeader->maptype & IPLANE)
  254.      {
  255.       MapHeader.mapinfopl=fsize;
  256.       nsize=RLEWCompress(MK_FP(MapInfoPl,0),size,MK_FP(block,0),MapFileHeader->RLEWtag);
  257.  
  258.       MapHeader.mapinfolen=nsize+2;
  259.  
  260.       if (XMSmaps)
  261.         XMSmove(0,(long)&size,XMStemp,fsize,2);
  262.       else
  263.         SaveFile(SM_name,(char huge *)&size,fsize,2);
  264.  
  265.       fsize+=2;
  266.  
  267.       if (XMSmaps)
  268.         XMSmove(0,(long)MK_FP(block,0),XMStemp,fsize,nsize);
  269.       else
  270.         SaveFile(SM_name,MK_FP(block,0),fsize,nsize);
  271.  
  272.       fsize+=nsize;
  273.      }
  274.        else
  275.      MapHeader.mapinfolen=0;
  276.  
  277.        if (XMSmaps)
  278.      XMSmove(0,(long)"!ID!",XMStemp,fsize,4);
  279.        else
  280.      SaveFile(SM_name,"!ID!",fsize,4);
  281.  
  282.        fsize+=4;
  283.  
  284.        MMFreePtr(&block);
  285.  
  286.        // RE-SAVE HEADER
  287.        if (XMSmaps)
  288.             XMSmove(0,(long)&MapHeader,XMStemp,
  289.                 MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
  290.        else
  291.             SaveFile(SM_name,(char huge *)&MapHeader,
  292.                 MapFileHeader->dataoffsets[whichmap],sizeof(MapHeaderStr));
  293.  
  294.        //
  295.        // RE-SAVE FILE HEADER
  296.        // NOTE: The "2" is so SaveFile doesn't truncate the fucking file!
  297.        //
  298.        SaveFile(mapheadname,MK_FP(MapFileHeader,2),2,sizeof(MapFileHeaderStr)-2);
  299.       }
  300.  
  301.     if (XMSmaps)
  302.       {
  303.        #define BCSIZE    0x4000
  304.        long size=fsize,clen,coff;
  305.  
  306.        //
  307.        // SAVE ENTIRE MAPFILE IN XMS TO DISK!
  308.        //
  309.        XMSFreeMem(XMSmaps);
  310.        XMSmaps=XMStemp;
  311.  
  312.        MMAllocate(&block,BCSIZE);
  313.        coff=0;
  314.        do
  315.        {
  316.         clen=BCSIZE;
  317.         if (size<BCSIZE)
  318.             clen=size;
  319.  
  320.         XMSmove(XMSmaps,coff,0,(long)MK_FP(block,0),clen);
  321.         SaveFile(SM_loadname,MK_FP(block,0),coff,clen);
  322.         size-=BCSIZE;
  323.         coff+=clen;
  324.  
  325.        } while(size>0);
  326.  
  327.        MMFreePtr(&block);
  328.       }
  329.     else
  330.       {
  331.        unlink(SM_loadname);
  332.        rename(SM_name,SM_loadname);
  333.       }
  334.    }
  335.  
  336.  AllocateUndoBuffers();
  337.  UndoRegion.x=-1;
  338.  SaveUndo(0,0,mapwidth,mapheight);
  339.  RestoreBackground();
  340. }
  341.  
  342.  
  343.  
  344.  
  345.  
  346.  
  347. ////////////////////////////////////////////////////
  348. //
  349. // BACKUP FILES!
  350. //
  351. ////////////////////////////////////////////////////
  352. void BackupFile(char *filename)
  353. {
  354.  #define BUFSIZE    0x8000
  355.  memptr block;
  356.  long size,clen,coff;
  357.  int i;
  358.  char backupname[14];
  359.  
  360.  
  361.  size = filelen(filename);
  362.  if (!size)
  363.    return;
  364.  
  365.  strcpy(backupname,filename);
  366.  for (i=strlen(backupname);i;i--)
  367.    if (backupname[i] == '.')
  368.      backupname[i+1] = 0;
  369.  strcat(backupname,"BAK");
  370.  
  371.  MMAllocate(&block,BUFSIZE);
  372.  coff=0;
  373.  do
  374.  {
  375.   clen=BUFSIZE;
  376.   if (size<BUFSIZE)
  377.       clen=size;
  378.  
  379.   LoadFile(filename,(char far *)block,coff,clen);
  380.   SaveFile(backupname,MK_FP(block,0),coff,clen);
  381.   size-=BUFSIZE;
  382.   coff+=clen;
  383.  
  384.  } while(size>0);
  385.  
  386.  MMFreePtr(&block);
  387. }
  388.  
  389.  
  390. ////////////////////////////////////////////////////
  391. //
  392. // SAVE OUT TEDINFO FILE
  393. //
  394. ////////////////////////////////////////////////////
  395. void SaveTEDInfo(void)
  396. {
  397.  BackupFile(infoname);
  398.  
  399.  TEDInfo->oscrx=xbase;
  400.  TEDInfo->oscry=ybase;
  401.  _fstrcpy(TEDInfo->launchname,(char far *)launchname);
  402.  SaveFile(infoname,MK_FP(TEDInfo,0),0,sizeof(InfoStruct));
  403. }
  404.  
  405.  
  406. ////////////////////////////////////////////////////
  407. //
  408. // WRITE OUT THE OUTPUT HEADER FILE
  409. //
  410. ////////////////////////////////////////////////////
  411. char * _nfstrcpy(char *dest,char far *source)
  412. {
  413.  int i;
  414.  
  415.  for (i=0;i<_fstrlen(source);i++)
  416.    *(dest+i)=*(source+i);
  417.  
  418.  return dest;
  419. }
  420.  
  421.  
  422. void SaveOutputHeader(void)
  423. {
  424.  char outhead[14]="MAPHEAD.",dot_h[14]="MAPS",t[15],tm[15],temp[40],temp1[40];
  425.  FILE *fp;
  426.  OutputHeadStr OutHead;
  427.  int i,Thelast;
  428.  long fsize;
  429.  
  430.  
  431.  ErrDialog("Saving header...","");
  432.  
  433.  strcat(outhead,ext);
  434.  
  435.  BackupFile(outhead);
  436.  
  437.  memset(&OutHead,0,sizeof(OutputHeadStr));
  438.  
  439.  OutHead.RLEWtag=MapFileHeader->RLEWtag;
  440.  
  441.  for (i=0;i<100;i++)
  442.    OutHead.dataoffsets[i]=MapFileHeader->dataoffsets[i];
  443.  
  444.  fsize=sizeof(OutputHeadStr);
  445.  SaveFile(outhead,(char huge *)&OutHead,0,fsize);
  446.  for (i=0;i<numtplanes;i++)
  447.    {
  448.     SaveFile(outhead,MK_FP(Tinfo[i],0),fsize,tilenum);
  449.     fsize+=tilenum;
  450.    }
  451.  for (i=0;i<numtmplanes;i++)
  452.    {
  453.     SaveFile(outhead,MK_FP(TMinfo[i],0),fsize,tilemnum);
  454.     fsize+=tilemnum;
  455.    }
  456.  
  457.  RestoreBackground();
  458.  
  459.  //
  460.  // DUMP OUT A MAPSext.H HEADER FILE
  461.  //
  462.  if (writeH)
  463.    {
  464.     ErrDialog("Saving .h file...","");
  465.  
  466.     strcat(dot_h,ext);
  467.     strcat(dot_h,".H");
  468.     unlink(dot_h);
  469.  
  470.     if ((fp=fopen(dot_h,"wt"))==NULL)
  471.       return;
  472.  
  473.     fprintf(fp,"///////////////////////////////////////\n");
  474.     fprintf(fp,"//\n");
  475.     fprintf(fp,"// TED5 Map Header for %s\n",ext);
  476.     fprintf(fp,"//\n");
  477.     fprintf(fp,"///////////////////////////////////////\n");
  478.  
  479.     Thelast=99;
  480.     for (i=99;i>=0;i--)
  481.       if (MapFileHeader->dataoffsets[i]>=0)
  482.       {
  483.        Thelast=i;
  484.        break;
  485.       }
  486.  
  487.  
  488.     fprintf(fp,"\n");
  489.     fprintf(fp,"//\n");
  490.     fprintf(fp,"// Map Names\n");
  491.     fprintf(fp,"//\n");
  492.  
  493.     fprintf(fp,"typedef enum {\n");
  494.     for (i=0;i<100;i++)
  495.       if (MapFileHeader->dataoffsets[i]>=0)
  496.     {
  497.      char temp[28];
  498.      int j;
  499.  
  500.  
  501.      strcpy(temp,&MapNames[i][0]);
  502.      strcat(temp,"_MAP");
  503.  
  504.      for (j=0;j<strlen(temp);j++)
  505.        if (temp[j]==' ')
  506.          temp[j]='_';
  507.  
  508.      strcat(temp,",");
  509.      while(strlen(temp)<25)
  510.        strcat(temp," ");
  511.  
  512.      fprintf(fp,"\t\t%s// %d\n",strupr(temp),i);
  513.     }
  514.       else
  515.     if (i<Thelast)
  516.       fprintf(fp,"\t\tEMPTYMAP%d,\n",i);
  517.  
  518.     fprintf(fp,"\t\tLASTMAP\n\t     } mapnames;\n");
  519.  
  520.     switch(tsize)
  521.     {
  522.      case 1:
  523.        strcpy(t,"NUMTILE8");
  524.        strcpy(tm,"NUMTILE8M");
  525.        break;
  526.      case 2:
  527.        strcpy(t,"NUMTILE16");
  528.        strcpy(tm,"NUMTILE16M");
  529.        break;
  530.      case 3:
  531.        strcpy(t,"NUMTILE32");
  532.        strcpy(tm,"NUMTILE32M");
  533.     }
  534.  
  535.  
  536.     if (numtplanes)
  537.     {
  538.      fprintf(fp,"\n");
  539.      fprintf(fp,"//\n");
  540.      fprintf(fp,"// TILEINFO offsets\n");
  541.      fprintf(fp,"//\n");
  542.  
  543.      memset(temp,0,sizeof(temp));
  544.      memset(temp1,0,sizeof(temp1));
  545.      fprintf(fp,"#define %s\x9\x9%d\n",
  546.        strupr(_nfstrcpy(temp,MapFileHeader->tnames[0])),
  547.        sizeof(OutputHeadStr));
  548.      for (i=1;i<numtplanes;i++)
  549.        {
  550.     memset(temp,0,sizeof(temp));
  551.     memset(temp1,0,sizeof(temp1));
  552.  
  553.     fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
  554.       strupr(_nfstrcpy(temp,MapFileHeader->tnames[i])),
  555.       strupr(_nfstrcpy(temp1,MapFileHeader->tnames[i-1])),
  556.       t);
  557.        }
  558.     }
  559.  
  560.     if (numtmplanes)
  561.     {
  562.      fprintf(fp,"\n");
  563.      fprintf(fp,"//\n");
  564.      fprintf(fp,"// TILEINFOM offsets\n");
  565.      fprintf(fp,"//\n");
  566.  
  567.      memset(temp,0,sizeof(temp));
  568.      memset(temp1,0,sizeof(temp1));
  569.      fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
  570.        strupr(_nfstrcpy(temp,MapFileHeader->tmnames[0])),
  571.        strupr(_nfstrcpy(temp1,MapFileHeader->tnames[numtplanes-1])),
  572.        t);
  573.      for (i=1;i<numtmplanes;i++)
  574.        {
  575.     memset(temp,0,sizeof(temp));
  576.     memset(temp1,0,sizeof(temp1));
  577.  
  578.     fprintf(fp,"#define %s\x9\x9(%s+%s)\n",
  579.       strupr(_nfstrcpy(temp,MapFileHeader->tmnames[i])),
  580.       strupr(_nfstrcpy(temp1,MapFileHeader->tmnames[i-1])),
  581.       tm);
  582.        }
  583.     }
  584.  
  585.     fclose(fp);
  586.     writeH=0;
  587.     RestoreBackground();
  588.    }
  589.  
  590. }
  591.  
  592.  
  593. ////////////////////////////////////////////////////
  594. //
  595. // Initialize the TILEINFO/M arrays
  596. //
  597. ////////////////////////////////////////////////////
  598. btype TIb[]={{"                  ",1,2,1},
  599.          {"                  ",1,6,1},
  600.          {" Done ",12,9,2}};
  601. DialogDef TId={" How many TILEINFO planes?\n\n\n\n"
  602.            " How many TILEINFOM planes?",
  603.            27,11,3,&TIb[0],NULL};
  604.  
  605. void InitTileinfo(void)
  606. {
  607.  unsigned temp,which,oktoexit=0,ox,oy,i,j;
  608.  long fsize;
  609.  
  610.  numtplanes=numtmplanes=0;
  611.  DrawDialog(&TId,1);
  612.  GetButtonXY(&TId,0,&sx,&sy);
  613.  printint(numtplanes);
  614.  if (MapFileHeader->maptype&FPLANE)
  615.    {
  616.     GetButtonXY(&TId,1,&sx,&sy);
  617.     printint(numtmplanes);
  618.    }
  619.  do
  620.  {
  621.   which=CheckButtons(&TId);
  622.   switch(which)
  623.   {
  624.    case 1:
  625.      MouseHide();
  626.      GetButtonXY(&TId,0,&sx,&sy);
  627.      ox=sx;
  628.      oy=sy;
  629.      print(TIb[0].text);
  630.      sx=ox;
  631.      sy=oy;
  632.      if ((temp=inputint(9))!=ESCOUT && temp<11 && temp)
  633.        numtplanes=temp;
  634.      sx=ox;
  635.      sy=oy;
  636.      print(TIb[0].text);
  637.      sx=ox;
  638.      sy=oy;
  639.      printint(numtplanes);
  640.      MouseShow();
  641.  
  642.    case 2:
  643.      MouseHide();
  644.      GetButtonXY(&TId,1,&sx,&sy);
  645.      ox=sx;
  646.      oy=sy;
  647.      print(TIb[1].text);
  648.      sx=ox;
  649.      sy=oy;
  650.      if (MapFileHeader->maptype&FPLANE)
  651.        {
  652.     if ((temp=inputint(9))!=ESCOUT && temp<11 && temp)
  653.       numtmplanes=temp;
  654.     sx=ox;
  655.     sy=oy;
  656.     print(TIb[1].text);
  657.     sx=ox;
  658.     sy=oy;
  659.     printint(numtmplanes);
  660.        }
  661.      MouseShow();
  662.      break;
  663.  
  664.    case 3:
  665.      MouseHide();
  666.      oktoexit=1;
  667.      GetButtonXY(&TId,2,&sx,&sy);
  668.      print(TIb[2].text);
  669.      MouseShow();
  670.   }
  671.  
  672.  } while(!oktoexit);
  673.  
  674.  RestoreBackground();
  675.  
  676.  //
  677.  // allocate arrays
  678.  //
  679.  fsize=sizeof(MapFileHeaderStr);
  680.  
  681.  for (i=0;i<numtplanes;i++)
  682.    {
  683.     MMAllocate((memptr *)&Tinfo[i],tilenum);
  684.     MapFileHeader->tileinfooff[i]=fsize;    // THIS DOESN'T REALLY MATTER
  685.     fsize+=tilenum;                // ....YET!
  686.     for(j=0;j<tilenum;j++)
  687.       *(Tinfo[i]+j)=0;
  688.    }
  689.  
  690.  for (i=0;i<numtmplanes;i++)
  691.    {
  692.     MMAllocate((memptr *)&TMinfo[i],tilemnum);
  693.     MapFileHeader->tileinfomoff[i]=fsize;
  694.     fsize+=tilemnum;
  695.     for(j=0;j<tilemnum;j++)
  696.       *(TMinfo[i]+j)=0;
  697.    }
  698.  
  699.  MapFileHeader->numtplanes=numtplanes;
  700.  MapFileHeader->numtmplanes=numtmplanes;
  701.  
  702.  MapFileHeader->oldtilenum=tilenum;
  703.  MapFileHeader->oldtilemnum=tilemnum;
  704.  writeH=1;
  705. }
  706.  
  707.  
  708. ////////////////////////////////////////////////////
  709. //
  710. // Item - Edit the TILEINFO names
  711. //
  712. ////////////////////////////////////////////////////
  713. btype TINb={" Done ",8,15,1};
  714. DialogDef TINd={"  Enter plane names:\n"
  715.         " TILEINFO   TILEINFOM",
  716.         22,17,1,&TINb,NULL};
  717.  
  718. void Item_EditTinfoNames(void)
  719. {
  720.  unsigned ox,oy,i,oktoexit=0;
  721.  int which;
  722.  
  723.  MouseHide();
  724.  DrawDialog(&TINd,1);
  725.  GetDialogXY(&TINd,&sx,&sy);
  726.  ox=sx;
  727.  oy=sy;
  728.  DrawBorder(sx,sy+2,10,11,1);
  729.  sx=ox;
  730.  sy=oy;
  731.  DrawBorder(sx+11,sy+2,10,11,1);
  732.  
  733.  for (i=0;i<10;i++)
  734.  {
  735.   sx=ox+1;
  736.   sy=oy+i+3;
  737.   fprint(MapFileHeader->tnames[i]);
  738.   sx=ox+12;
  739.   sy=oy+i+3;
  740.   fprint(MapFileHeader->tmnames[i]);
  741.  }
  742.  MouseShow();
  743.  
  744.  do
  745.  {
  746.   if ((which=CheckList(ox+1,oy+3,8,numtplanes,TInfoNon,TInfoNoff,0))>=0)
  747.     {
  748.      char temp[8];
  749.  
  750.      MouseHide();
  751. redo:
  752.      sx=ox+1;
  753.      sy=oy+which+3;
  754.      print("         ");
  755.      sx=ox+1;
  756.      sy=oy+which+3;
  757.      if (input(temp,7))
  758.        {
  759.     for(i=0;i<8;i++)
  760.       MapFileHeader->tnames[which][i]=temp[i];
  761.     which++;
  762.     writeH=DirtyFlag=1;
  763.     if (which<numtplanes)
  764.       goto redo;
  765.        }
  766.      else
  767.        TInfoNoff(ox+1,oy+3+which,which);
  768.     MouseShow();
  769.     }
  770.  
  771.   if ((which=CheckList(ox+12,oy+3,8,numtmplanes,TInfoMNon,TInfoMNoff,0))>=0)
  772.     {
  773.      char temp[8];
  774.  
  775.      MouseHide();
  776. redo1:
  777.      sx=ox+12;
  778.      sy=oy+which+3;
  779.      print("         ");
  780.      sx=ox+12;
  781.      sy=oy+which+3;
  782.      if (input(temp,7))
  783.        {
  784.     for(i=0;i<8;i++)
  785.       MapFileHeader->tmnames[which][i]=temp[i];
  786.     which++;
  787.     writeH=DirtyFlag=1;
  788.     if (which<numtmplanes)
  789.       goto redo1;
  790.        }
  791.      else
  792.        TInfoMNoff(ox+12,oy+3+which,which);
  793.     MouseShow();
  794.     }
  795.  
  796.   GetButtonXY(&TINd,0,&sx,&sy);
  797.   if (!CheckList(sx,sy,6,1,TIDoneOn,TIDoneOff,1))
  798.     oktoexit++;
  799.  
  800.   if (keydown[1])
  801.     {
  802.      while(keydown[1]);
  803.      oktoexit++;
  804.     }
  805.  }while(!oktoexit);
  806.  
  807.  RestoreBackground();
  808. }
  809.  
  810. void TInfoNon(int x,int y,int b)
  811. {
  812.  xormask=1;
  813.  sx=x;
  814.  sy=y;
  815.  if (!MapFileHeader->tnames[b][0])
  816.    print("         ");
  817.  else
  818.    fprint(MapFileHeader->tnames[b]);
  819.  xormask=0;
  820. }
  821. void TInfoNoff(int x,int y,int b)
  822. {
  823.  sx=x;
  824.  sy=y;
  825.  if (!MapFileHeader->tnames[b][0])
  826.    print("         ");
  827.  else
  828.    fprint(MapFileHeader->tnames[b]);
  829. }
  830. void TInfoMNon(int x,int y,int b)
  831. {
  832.  xormask=1;
  833.  sx=x;
  834.  sy=y;
  835.  if (!MapFileHeader->tmnames[b][0])
  836.    print("         ");
  837.  else
  838.    fprint(MapFileHeader->tmnames[b]);
  839.  xormask=0;
  840. }
  841. void TInfoMNoff(int x,int y,int b)
  842. {
  843.  sx=x;
  844.  sy=y;
  845.  if (!MapFileHeader->tmnames[b][0])
  846.    print("         ");
  847.  else
  848.    fprint(MapFileHeader->tmnames[b]);
  849. }
  850. void TIDoneOn(int x,int y)
  851. {
  852.  xormask=1;
  853.  sx=x;
  854.  sy=y;
  855.  print(" Done ");
  856.  xormask=0;
  857. }
  858. void TIDoneOff(int x,int y)
  859. {
  860.  sx=x;
  861.  sy=y;
  862.  print(" Done ");
  863. }
  864.  
  865. ////////////////////////////////////////////////////
  866. //
  867. // Create a new map!
  868. //
  869. ////////////////////////////////////////////////////
  870. void CreateMap(int exitok)
  871. {
  872.  unsigned lwidth,lheight,i;
  873.  int mapnum;
  874.  long size;
  875.  char lname[16];
  876.  
  877.  if ((mapnum=SelectMap(exitok,NOTCREATED,"TO CREATE"))==-1)
  878.    return;
  879.  
  880.  InputMap(lname,&lwidth,&lheight,exitok);
  881.  if (!lname[0])
  882.    return;
  883.  
  884.  RemoveUndoBuffers();
  885.  SaveCutBuffers();
  886.  
  887.  if (MapBkgnd)
  888.    {
  889.     MMFreePtr((memptr *)&MapBkgnd);
  890.     MMFreePtr((memptr *)&CutBkgnd);
  891.    }
  892.  if (MapFrgnd)
  893.    {
  894.     MMFreePtr((memptr *)&MapFrgnd);
  895.     MMFreePtr((memptr *)&CutFrgnd);
  896.    }
  897.  if (MapInfoPl)
  898.    {
  899.     MMFreePtr((memptr *)&MapInfoPl);
  900.     MMFreePtr((memptr *)&CutInfoPl);
  901.    }
  902.  
  903.  size=2L*(lwidth*lheight);
  904.  
  905.  if (MapFileHeader->maptype&BPLANE)
  906.    {
  907.     MMAllocate((memptr *)&MapBkgnd,size);
  908.     MMAllocate((memptr *)&CutBkgnd,size);
  909.     for(i=0;i<lwidth*lheight;i++)
  910.       *(MapBkgnd+i)=*(CutBkgnd+i)=0;
  911.    }
  912.  if (MapFileHeader->maptype&FPLANE)
  913.    {
  914.     MMAllocate((memptr *)&MapFrgnd,size);
  915.     MMAllocate((memptr *)&CutFrgnd,size);
  916.     for(i=0;i<lwidth*lheight;i++)
  917.       *(MapFrgnd+i)=*(CutFrgnd+i)=0;
  918.    }
  919.  if (MapFileHeader->maptype&IPLANE)
  920.    {
  921.     MMAllocate((memptr *)&MapInfoPl,size);
  922.     MMAllocate((memptr *)&CutInfoPl,size);
  923.     for(i=0;i<lwidth*lheight;i++)
  924.       *(MapInfoPl+i)=*(CutInfoPl+i)=0;
  925.    }
  926.  
  927.  whichmap=mapnum;
  928.  strcpy(MapHeader.name,lname);
  929.  MapHeader.width=mapwidth=lwidth;
  930.  MapHeader.height=mapheight=lheight;
  931.  strcpy(MapNames[mapnum],MapHeader.name);
  932.  AllocateUndoBuffers();
  933.  DirtyFlag=1;
  934.  SaveMap(0);
  935.  DirtyFlag=0;
  936.  RestoreCutBuffers();
  937.  SelectMode=PasteMode=xbase=ybase=0;
  938.  SelX1=SelX2=SelY1=SelY2=-1;
  939.  writeH=1;
  940. }
  941.  
  942.  
  943. ////////////////////////////////////////////////////
  944. //
  945. // Load a map
  946. //
  947. ////////////////////////////////////////////////////
  948. void LoadMap(int mapnum)
  949. {
  950.  unsigned long csize,size=0;
  951.  memptr block;
  952.  
  953.  SaveCutBuffers();
  954.  //
  955.  // DEALLOCATE ALL CURRENT MAP MEMORY
  956.  //
  957.  RemoveUndoBuffers();
  958.  
  959.  if (MapBkgnd)
  960.    {
  961.     MMFreePtr((memptr *)&MapBkgnd);
  962.     MMFreePtr((memptr *)&CutBkgnd);
  963.    }
  964.  if (MapFrgnd)
  965.    {
  966.     MMFreePtr((memptr *)&MapFrgnd);
  967.     MMFreePtr((memptr *)&CutFrgnd);
  968.    }
  969.  if (MapInfoPl)
  970.    {
  971.     MMFreePtr((memptr *)&MapInfoPl);
  972.     MMFreePtr((memptr *)&CutInfoPl);
  973.    }
  974.  
  975.  //
  976.  // LOAD MAP HEADER
  977.  //
  978.  if (XMSmaps)
  979.    XMSmove(XMSmaps,MapFileHeader->dataoffsets[mapnum],0,(long)&MapHeader,sizeof(MapHeaderStr));
  980.  else
  981.    LoadFile(mapname,(char huge *)&MapHeader,MapFileHeader->dataoffsets[mapnum],sizeof(MapHeaderStr));
  982.  
  983.  //
  984.  // LOAD & DECOMPRESS MAP PLANES
  985.  //
  986.  if (MapFileHeader->maptype & BPLANE)
  987.    {
  988.     if (XMSmaps)
  989.       XMSmove(XMSmaps,MapHeader.mapbkgndpl,0,(long)&size,2);
  990.     else
  991.       LoadFile(mapname,(char huge *)&size,MapHeader.mapbkgndpl,2);
  992.  
  993.     MMAllocate((memptr *)&MapBkgnd,size);
  994.     MMAllocate((memptr *)&CutBkgnd,size);
  995.     csize=MapHeader.mapbkgndlen-2;
  996.     MMAllocate(&block,csize);
  997.  
  998.     if (XMSmaps)
  999.       XMSmove(XMSmaps,MapHeader.mapbkgndpl+2,0,(long)MK_FP(block,0),csize);
  1000.     else
  1001.       LoadFile(mapname,MK_FP(block,0),MapHeader.mapbkgndpl+2,csize);
  1002.  
  1003.     RLEWExpand(MK_FP(block,0),MK_FP(MapBkgnd,0),size,MapFileHeader->RLEWtag);
  1004.     MMFreePtr(&block);
  1005.    }
  1006.  if (MapFileHeader->maptype & FPLANE)
  1007.    {
  1008.     if (XMSmaps)
  1009.       XMSmove(XMSmaps,MapHeader.mapfrgndpl,0,(long)&size,2);
  1010.     else
  1011.       LoadFile(mapname,(char huge *)&size,MapHeader.mapfrgndpl,2);
  1012.  
  1013.     MMAllocate((memptr *)&MapFrgnd,size);
  1014.     MMAllocate((memptr *)&CutFrgnd,size);
  1015.     csize=MapHeader.mapfrgndlen-2;
  1016.     MMAllocate(&block,csize);
  1017.  
  1018.     if (XMSmaps)
  1019.       XMSmove(XMSmaps,MapHeader.mapfrgndpl+2,0,(long)MK_FP(block,0),csize);
  1020.     else
  1021.       LoadFile(mapname,MK_FP(block,0),MapHeader.mapfrgndpl+2,csize);
  1022.  
  1023.     RLEWExpand(MK_FP(block,0),MK_FP(MapFrgnd,0),size,MapFileHeader->RLEWtag);
  1024.     MMFreePtr(&block);
  1025.    }
  1026.  if (MapFileHeader->maptype & IPLANE)
  1027.    {
  1028.     if (XMSmaps)
  1029.       XMSmove(XMSmaps,MapHeader.mapinfopl,0,(long)&size,2);
  1030.     else
  1031.       LoadFile(mapname,(char huge *)&size,MapHeader.mapinfopl,2);
  1032.  
  1033.     MMAllocate((memptr *)&MapInfoPl,size);
  1034.     MMAllocate((memptr *)&CutInfoPl,size);
  1035.     csize=MapHeader.mapinfolen-2;
  1036.     MMAllocate(&block,csize);
  1037.  
  1038.     if (XMSmaps)
  1039.       XMSmove(XMSmaps,MapHeader.mapinfopl+2,0,(long)MK_FP(block,0),csize);
  1040.     else
  1041.       LoadFile(mapname,MK_FP(block,0),MapHeader.mapinfopl+2,csize);
  1042.  
  1043.     RLEWExpand(MK_FP(block,0),MK_FP(MapInfoPl,0),size,MapFileHeader->RLEWtag);
  1044.     MMFreePtr(&block);
  1045.    }
  1046.  
  1047.  mapwidth=MapHeader.width;
  1048.  mapheight=MapHeader.height;
  1049.  strcpy(MapNames[mapnum],MapHeader.name);
  1050.  
  1051.  AllocateUndoBuffers();
  1052.  UndoRegion.x=-1;
  1053.  SaveUndo(0,0,mapwidth,mapheight);
  1054.  RestoreCutBuffers();
  1055.  
  1056.  SelectMode=PasteMode=xbase=ybase=0;
  1057.  SelX1=SelX2=SelY1=SelY2=-1;
  1058. }
  1059.  
  1060.  
  1061. ////////////////////////////////////////////////////
  1062. //
  1063. // Select a new map!
  1064. //
  1065. ////////////////////////////////////////////////////
  1066. btype ClvlB[]={{"\xb",28,5,1},
  1067.            {"\xc",28,14,1},
  1068.            {" Exit ",12,17,1}};
  1069. DialogDef ClvlD={"          SELECT MAP",
  1070.          30,19,2,&ClvlB[0],NULL};
  1071. int smbase=0;
  1072.  
  1073. int SelectMap(int exitok,int createflg,char *title)
  1074. {
  1075.  MapHeaderStr TempMapHeader;
  1076.  unsigned ox,oy,i,dx,dy;
  1077.  int select=-1,redraw;
  1078.  
  1079.  if (exitok)
  1080.    {
  1081.     ClvlD.numbuttons=3;
  1082.     ClvlD.height=19;
  1083.    }
  1084.  else
  1085.    {
  1086.     ClvlD.numbuttons=2;
  1087.     ClvlD.height=16;
  1088.    }
  1089.  
  1090.  DrawDialog(&ClvlD,1);
  1091.  GetDialogXY(&ClvlD,&dx,&dy);
  1092.  sy=dy+1;
  1093.  sx=screencenterx-strlen(title)/2;
  1094.  print(title);
  1095.  
  1096.  dx+=3;
  1097.  dy+=5;
  1098.  
  1099.  MouseHide();
  1100.  GetButtonXY(&ClvlD,0,&sx,&sy);
  1101.  sx-=27;
  1102.  sy-=2;
  1103.  print("Map   Name\n");
  1104.  ox=sx+1;
  1105.  oy=sy+1;
  1106.  DrawBorder(sx,sy,26,11,2);
  1107.  MouseShow();
  1108.  
  1109.  
  1110.  do
  1111.  {
  1112.   int mx,my;
  1113.  
  1114.   //
  1115.   // DRAW MAP NAMES
  1116.   //
  1117.   MouseHide();
  1118.   for (i=0;i<10;i++)
  1119.   {
  1120.    sy=oy+i;
  1121.    sx=ox;
  1122.    if (i+smbase==whichmap)
  1123.      print("*");
  1124.    else
  1125.      print(" ");
  1126.  
  1127.    printint(i+smbase);
  1128.    print(" ");
  1129.    sx=ox+5;
  1130.    MNameOff(sx,sy,i);
  1131.   }
  1132.   MouseShow();
  1133.   redraw=0;
  1134.  
  1135.   do
  1136.   {
  1137.    GetButtonXY(&ClvlD,0,&(unsigned)mx,&(unsigned)my);
  1138.    if (!CheckList(mx,my,1,1,UparOn,UparOff,0) || keydown[0x48])
  1139.      {
  1140.       MouseHide();
  1141.       GetButtonXY(&ClvlD,0,&sx,&sy);
  1142.       print(ClvlB[0].text);
  1143.  
  1144.       smbase-=10;
  1145.       if (smbase<0)
  1146.     smbase=0;
  1147.       redraw=1;
  1148.       MouseShow();
  1149.       while(keydown[0x48]);
  1150.       continue;
  1151.      }
  1152.  
  1153.    GetButtonXY(&ClvlD,1,&(unsigned)mx,&(unsigned)my);
  1154.    if (!CheckList(mx,my,1,1,DnarOn,DnarOff,0) || keydown[0x50])
  1155.      {
  1156.       MouseHide();
  1157.       GetButtonXY(&ClvlD,1,&sx,&sy);
  1158.       print(ClvlB[1].text);
  1159.  
  1160.       smbase+=10;
  1161.       if (smbase>90)
  1162.     smbase=90;
  1163.       redraw=1;
  1164.       MouseShow();
  1165.       while(keydown[0x50]);
  1166.       continue;
  1167.      }
  1168.  
  1169.    if (exitok)
  1170.      {
  1171.       GetButtonXY(&ClvlD,2,&(unsigned)mx,&(unsigned)my);
  1172.       if (!CheckList(mx,my,6,1,ExitOn,ExitOff,0))
  1173.     {
  1174.      RestoreBackground();
  1175.      return -1;
  1176.     }
  1177.      }
  1178.  
  1179.    if (exitok && keydown[1])
  1180.      {
  1181.       RestoreBackground();
  1182.       return -1;
  1183.      }
  1184.  
  1185.    select=CheckList(ox+5,oy,20,10,MNameOn,MNameOff,0);
  1186.    if (select>=0)
  1187.      {
  1188.       MouseHide();
  1189.       sy=select+oy;
  1190.       sx=ox+5;
  1191.       MNameOff(sx,sy,select);
  1192.       MouseShow();
  1193.       if ((MapFileHeader->dataoffsets[select+smbase]!=-1 && createflg==NOTCREATED)||
  1194.       (MapFileHeader->dataoffsets[select+smbase]==-1 && createflg==CREATED))
  1195.     select=-1;
  1196.      }
  1197.  
  1198.   } while(!redraw && select<0);
  1199.  } while(select<0);
  1200.  
  1201.  RestoreBackground();
  1202.  return select+smbase;
  1203. }
  1204.  
  1205. //
  1206. // Print arrows
  1207. //
  1208. void DnarOn(int x,int y)
  1209. {
  1210.  sx=x;
  1211.  sy=y;
  1212.  xormask=1;
  1213.  drawchar(sx,sy,0xc);
  1214.  xormask=0;
  1215. }
  1216. void DnarOff(int x,int y)
  1217. {
  1218.  sx=x;
  1219.  sy=y;
  1220.  drawchar(sx,sy,0xc);
  1221. }
  1222. void UparOn(int x,int y)
  1223. {
  1224.  sx=x;
  1225.  sy=y;
  1226.  xormask=1;
  1227.  drawchar(sx,sy,0xb);
  1228.  xormask=0;
  1229. }
  1230. void UparOff(int x,int y)
  1231. {
  1232.  sx=x;
  1233.  sy=y;
  1234.  drawchar(sx,sy,0xb);
  1235. }
  1236. void ExitOn(int x,int y)
  1237. {
  1238.  sx=x;
  1239.  sy=y;
  1240.  xormask=1;
  1241.  print(" Exit ");
  1242.  xormask=0;
  1243. }
  1244. void ExitOff(int x,int y)
  1245. {
  1246.  sx=x;
  1247.  sy=y;
  1248.  print(" Exit ");
  1249. }
  1250.  
  1251. //
  1252. // Highlight Map Name
  1253. //
  1254. void MNameOn(int x,int y,int i)
  1255. {
  1256.  xormask=1;
  1257.  MNameOff(x,y,i);
  1258.  xormask=0;
  1259. }
  1260.  
  1261. //
  1262. // De-Highlight Map Name
  1263. //
  1264. void MNameOff(int x,int y,int i)
  1265. {
  1266.  MapHeaderStr TempMapHeader;
  1267.  
  1268.  sx=x;
  1269.  sy=y;
  1270.  if (MapFileHeader->dataoffsets[i+smbase]!=-1)
  1271.    {
  1272.     print("                   ");
  1273.     sx=x;
  1274.     print(MapNames[i+smbase]);
  1275.    }
  1276.  else
  1277.    print("--not created yet--");
  1278. }
  1279.  
  1280.  
  1281.  
  1282. ////////////////////////////////////////////////////
  1283. //
  1284. // Pick more planes for the map set
  1285. //
  1286. ////////////////////////////////////////////////////
  1287. btype PickPlaneb[]={{"X",1,3,1},
  1288.             {"X",1,6,1},
  1289.             {" Done ",1,9,2}};
  1290. DialogDef PickPlaneD={"Which other planes\n"
  1291.              "to enable?\n\n"
  1292.              "    Foreground\n\n\n"
  1293.              "    Information"
  1294.              ,18,11,3,&PickPlaneb[0],NULL};
  1295.  
  1296. int PickMorePlanes(void)
  1297. {
  1298.  int which;
  1299.  char planes=7;    // 1=bkgnd/2=frgnd/4=info
  1300.  
  1301.  DrawDialog(&PickPlaneD,1);
  1302.  do
  1303.  {
  1304.   which=CheckButtons(&PickPlaneD);
  1305.   switch(which)
  1306.   {
  1307.    case 0:
  1308.      RestoreBackground();
  1309.      return 1;
  1310.    case 1:
  1311.      GetButtonXY(&PickPlaneD,0,&sx,&sy);
  1312.      planes^=2;
  1313.      MouseHide();
  1314.      if (planes&2)
  1315.        print("X");
  1316.      else
  1317.        print(" ");
  1318.      MouseShow();
  1319.      break;
  1320.    case 2:
  1321.      GetButtonXY(&PickPlaneD,1,&sx,&sy);
  1322.      planes^=4;
  1323.      MouseHide();
  1324.      if (planes&4)
  1325.        print("X");
  1326.      else
  1327.        print(" ");
  1328.      MouseShow();
  1329.   }
  1330.  } while(which!=3);
  1331.  
  1332.  RestoreBackground();
  1333.  MapFileHeader->maptype=planes;
  1334.  return 0;
  1335. }
  1336.  
  1337. ////////////////////////////////////////////////////
  1338. //
  1339. // Get map dimensions
  1340. //
  1341. ////////////////////////////////////////////////////
  1342. btype LvlSpecb[]={{"                  ",1,3,1},
  1343.           {"                  ",1,7,1},
  1344.           {"                  ",1,11,1},
  1345.           {" Done ",7,14,2}};
  1346. DialogDef LvlSpec={"   MAP DIMENSIONS\n"
  1347.            " Map Name:\n\n\n\n"
  1348.            " Map Width:\n\n\n\n"
  1349.            " Map Height:\n",
  1350.            20,16,4,&LvlSpecb[0],NULL};
  1351.  
  1352. void InputMap(char *lvlname,unsigned *levelw,unsigned *levelh,int exitok)
  1353. {
  1354.  unsigned butn,ok=0,nameok=0,widok=0,heightok=0,
  1355.      ox,oy,width=0,height=0,oldwidth=0,oldheight=0;
  1356.  char oldname[16]="",name[16]="";
  1357.  
  1358.  MouseHide();
  1359.  DrawDialog(&LvlSpec,1);
  1360.  GetButtonXY(&LvlSpec,1,&sx,&sy);
  1361.  printint(width);
  1362.  GetButtonXY(&LvlSpec,2,&sx,&sy);
  1363.  printint(height);
  1364.  MouseShow();
  1365.  
  1366.  //
  1367.  // START INPUT IMMEDIATELY
  1368.  //
  1369.  butn=1;
  1370.  goto firsttime;
  1371.  
  1372. #pragma warn -rch
  1373.  while (!ok)
  1374. #pragma warn +rch
  1375.  {
  1376.   butn=CheckButtons(&LvlSpec);
  1377.   if (!butn)
  1378.      if (exitok)
  1379.       {
  1380.        RestoreBackground();
  1381.        lvlname[0]=0;
  1382.        return;
  1383.       }
  1384.      else
  1385.       continue;
  1386.  
  1387. firsttime:
  1388.  
  1389.   xormask=0;
  1390.   GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
  1391.   MouseHide();
  1392.   ox=sx;
  1393.   oy=sy;
  1394.   print(LvlSpecb[butn-1].text);
  1395.   sx=ox;
  1396.   sy=oy;
  1397.   switch(butn)
  1398.   {
  1399.    case 1:
  1400.      name[0]=0;
  1401.      if (!input(name,15))
  1402.        {
  1403.     strcpy(name,oldname);
  1404.     sx=ox;
  1405.     sy=oy;
  1406.     print(LvlSpecb[butn-1].text);
  1407.        }
  1408.      strcpy(oldname,name);
  1409.      sx=ox;
  1410.      sy=oy;
  1411.      if (name[0])
  1412.          {
  1413.     print(name);
  1414.     nameok=1;
  1415.        }
  1416.      else
  1417.        nameok=0;
  1418.  
  1419.      if (nameok)
  1420.        {
  1421.     butn=2;
  1422.     GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
  1423.     ox=sx;
  1424.     oy=sy;
  1425.     print(LvlSpecb[butn-1].text);
  1426.     sx=ox;
  1427.     sy=oy;
  1428.        }
  1429.      else
  1430.      break;
  1431.  
  1432.    case 2:
  1433.      width=0;
  1434.      if ((width=inputint(9))==ESCOUT)
  1435.        {
  1436.     widok=0;
  1437.     width=oldwidth;
  1438.        }
  1439.      if (width)
  1440.        widok=1;
  1441.  
  1442.      oldwidth=width;
  1443.      sx=ox;
  1444.      sy=oy;
  1445.      print(LvlSpecb[butn-1].text);
  1446.       sx=ox;
  1447.      sy=oy;
  1448.      printint(width);
  1449.      if (widok)
  1450.        {
  1451.     butn=3;
  1452.     GetButtonXY(&LvlSpec,butn-1,&sx,&sy);
  1453.     ox=sx;
  1454.     oy=sy;
  1455.     print(LvlSpecb[butn-1].text);
  1456.     sx=ox;
  1457.     sy=oy;
  1458.        }
  1459.      else
  1460.      break;
  1461.  
  1462.    case 3:
  1463.      height=0;
  1464.      if ((height=inputint(9))==ESCOUT)
  1465.        {
  1466.     heightok=0;
  1467.     height=oldheight;
  1468.        }
  1469.      if (height)
  1470.        heightok=1;
  1471.  
  1472.      oldheight=height;
  1473.      sx=ox;
  1474.      sy=oy;
  1475.      print(LvlSpecb[butn-1].text);
  1476.      sx=ox;
  1477.      sy=oy;
  1478.      printint(height);
  1479.      break;
  1480.  
  1481.    case 4:
  1482.      if (2L*height*width>0x10000)    // TOO BIG! TRIM IT!
  1483.        {
  1484.     errsound();
  1485.     errsound();
  1486.     widok=heightok=0;
  1487.     break;
  1488.        }
  1489.      if (nameok && widok && heightok)
  1490.        ok=1;
  1491.   }
  1492.  
  1493.   MouseShow();
  1494.  }
  1495.  
  1496.  RestoreBackground();
  1497.  
  1498.  *levelw=width;
  1499.  *levelh=height;
  1500.  strcpy(lvlname,name);
  1501. }
  1502.  
  1503. ////////////////////////////////////////////////////
  1504. //
  1505. // Item - Input INFOPLANE value
  1506. //
  1507. ////////////////////////////////////////////////////
  1508. btype EnterIVb={"          ",1,3,1};
  1509. DialogDef EnterIV={"Enter a value for\nthe INFO plane:\n\n\n",18,5,1,&EnterIVb,NULL};
  1510.  
  1511. void Item_InputInfoplane(void)
  1512. {
  1513.  unsigned val;
  1514.  
  1515.  
  1516.  if (TsearchMode || BfillMode || FillMode || PasteMode || SelectMode)
  1517.    return;
  1518.  
  1519.  clearkeys();
  1520.  DrawDialog(&EnterIV,1);
  1521.  MouseHide();
  1522.  GetButtonXY(&EnterIV,0,&sx,&sy);
  1523.  if ((val=inputint(9))!=ESCOUT)
  1524.    whichi=val+tilenum;
  1525.  RestoreBackground();
  1526.  DrawInfoBar();
  1527.  MouseShow();
  1528. }
  1529.  
  1530. ////////////////////////////////////////////////////
  1531. //
  1532. // Item - Select Tile
  1533. //
  1534. ////////////////////////////////////////////////////
  1535. void Item_SelectTile(void)
  1536. {
  1537.  SelectTiles(0);
  1538. }
  1539.  
  1540. ////////////////////////////////////////////////////
  1541. //
  1542. // Item - Block Fill
  1543. //
  1544. ////////////////////////////////////////////////////
  1545. void Item_BlockFill(void)
  1546. {
  1547.  ZeroModes();
  1548.  BfillMode=1;
  1549.  DrawInfoBar();
  1550. }
  1551.  
  1552. //
  1553. // DO THE ACTUAL BLOCK FILL
  1554. //
  1555. void DoBlockFill(void)
  1556. {
  1557.  unsigned loc,i,j,ctrl=0,newt,newm,newi,tton,tmon,tion,from;
  1558.  
  1559.  if (keydown[0x1d])
  1560.    ctrl++;
  1561.  
  1562.  MouseHide();
  1563.  
  1564.  CopyUndoRegion();
  1565.  UndoRegion.x=SelX1;
  1566.  UndoRegion.y=SelY1;
  1567.  UndoRegion.w=SelX2-SelX1+1;
  1568.  UndoRegion.h=SelY2-SelY1+1;
  1569.  
  1570.  if (ctrl)
  1571.    {
  1572.     for (j=SelY1;j<=SelY2;j++)
  1573.       for (i=SelX1;i<=SelX2;i++)
  1574.     {
  1575.      loc=j*mapwidth+i;
  1576.      from=(TileCopy.y+((j-SelY1)%TileCopy.h))*mapwidth+
  1577.           TileCopy.x+((i-SelX1)%TileCopy.w);
  1578.  
  1579.      switch(TileCopy.MapOrTileSelect)
  1580.      {
  1581.       case 0: // COPY BUFFER
  1582.          tton=TileCopy.PlanesCopied&BPLANE;
  1583.         tmon=TileCopy.PlanesCopied&FPLANE;
  1584.         tion=TileCopy.PlanesCopied&IPLANE;
  1585.  
  1586.         newt=CutBkgnd[from];
  1587.         newm=CutFrgnd[from];
  1588.         newi=CutInfoPl[from];
  1589.  
  1590.         break;
  1591.       case 1: // TILES
  1592.         tton=1;
  1593.         tmon=tion=0;
  1594.  
  1595.         newt=((j%TileCopy.h)+TileCopy.y)*selectcols+
  1596.          TileCopy.x+(i%TileCopy.w);
  1597.         if (XMSlookup[newt]<0)
  1598.           tton=0;
  1599.         break;
  1600.       case 2: // MASKED
  1601.         tton=tion=0;
  1602.         tmon=1;
  1603.  
  1604.         newm=((j%TileCopy.h)+TileCopy.y)*selectcols+
  1605.          TileCopy.x+(i%TileCopy.w)+tilenum+maxiconrows*selectcols;
  1606.         if (XMSlookup[newm]<0)
  1607.           tmon=0;
  1608.         else
  1609.           newm-=tilenum;
  1610.      }
  1611.  
  1612.      if (tton)
  1613.        *(MapBkgnd+loc)=newt;
  1614.      if (tmon)
  1615.        *(MapFrgnd+loc)=newm;
  1616.      if (tion)
  1617.        *(MapInfoPl+loc)=newi;
  1618.  
  1619.      if (j>=ybase && j<ybase+screenh &&
  1620.          i>=xbase && i<xbase+screenw)
  1621.        {
  1622.         int tempt,tempm,tempi;
  1623.  
  1624.         tempt=*(MapBkgnd+loc);
  1625.         tempm=*(MapFrgnd+loc)+tilenum;
  1626.         tempi=*(MapInfoPl+loc)+tilenum;
  1627.  
  1628.         CombineTiles(viewton?tempt:-BkgndColor,viewmon*tempm,viewion*tempi,tsize);
  1629.         if (GridMode)
  1630.           Overlay(tsize);
  1631.         DrawTile((i-xbase)<<(tsize-1),((j-ybase)<<(tsize+2))+8,tsize);
  1632.        }
  1633.     }
  1634.    }
  1635.  else
  1636.    for (j=SelY1;j<=SelY2;j++)
  1637.      for (i=SelX1;i<=SelX2;i++)
  1638.        {
  1639.     loc=j*mapwidth+i;
  1640.  
  1641.     if (planeton)
  1642.       *(MapBkgnd+loc)=whicht;
  1643.     if (planemon)
  1644.       *(MapFrgnd+loc)=whichtm-tilenum;
  1645.     if (planeion)
  1646.       *(MapInfoPl+loc)=whichi-tilenum;
  1647.  
  1648.     if (j>=ybase && j<ybase+screenh &&
  1649.         i>=xbase && i<xbase+screenw)
  1650.       {
  1651.        int tempt,tempm,tempi;
  1652.  
  1653.        tempt=*(MapBkgnd+loc);
  1654.        tempm=*(MapFrgnd+loc)+tilenum;
  1655.        tempi=*(MapInfoPl+loc)+tilenum;
  1656.  
  1657.        CombineTiles(viewton?tempt:-BkgndColor,viewmon*tempm,viewion*tempi,tsize);
  1658.        if (GridMode)
  1659.          Overlay(tsize);
  1660.        DrawTile((i-xbase)<<(tsize-1),((j-ybase)<<(tsize+2))+8,tsize);
  1661.       }
  1662.        }
  1663.  
  1664.  DirtyFlag=1;
  1665.  MouseShow();
  1666. }
  1667.  
  1668.  
  1669. ////////////////////////////////////////////////////
  1670. //
  1671. // Remove the XMS undo buffers
  1672. //
  1673. ////////////////////////////////////////////////////
  1674. void RemoveUndoBuffers(void)
  1675. {
  1676.  if (XMSundoB)
  1677.    XMSFreeMem(XMSundoB);
  1678.  if (XMSundoF)
  1679.    XMSFreeMem(XMSundoF);
  1680.  if (XMSundoI)
  1681.    XMSFreeMem(XMSundoI);
  1682.  
  1683.  XMSundoB=XMSundoF=XMSundoI=0;
  1684. }
  1685.  
  1686.  
  1687. ////////////////////////////////////////////////////
  1688. //
  1689. // Allocate XMS undo buffers
  1690. // NOTE: uses "mapwidth" & "mapheight"
  1691. //
  1692. ////////////////////////////////////////////////////
  1693. void AllocateUndoBuffers(void)
  1694. {
  1695.  long size=2L*mapwidth*mapheight;
  1696.  
  1697.  if (MapFileHeader->maptype&BPLANE)
  1698.    XMSundoB=XMSAllocate(size);
  1699.  if (MapFileHeader->maptype&FPLANE)
  1700.    XMSundoF=XMSAllocate(size);
  1701.  if (MapFileHeader->maptype&IPLANE)
  1702.    XMSundoI=XMSAllocate(size);
  1703. }
  1704.  
  1705.  
  1706. ////////////////////////////////////////////////////
  1707. //
  1708. // Save Undo buffers
  1709. //
  1710. ////////////////////////////////////////////////////
  1711. void SaveUndo(int x,int y,int w,int h)
  1712. {
  1713.  unsigned hsize=w*2,j;
  1714.  
  1715.  for (j=y;j<y+h;j++)
  1716.    {
  1717.     unsigned off=2*(j*mapwidth+x);
  1718.  
  1719.     if (MapFileHeader->maptype&BPLANE)
  1720.       XMSmove(0,(long)MK_FP(MapBkgnd,off),XMSundoB,off,hsize);
  1721.     if (MapFileHeader->maptype&FPLANE)
  1722.       XMSmove(0,(long)MK_FP(MapFrgnd,off),XMSundoF,off,hsize);
  1723.     if (MapFileHeader->maptype&IPLANE)
  1724.       XMSmove(0,(long)MK_FP(MapInfoPl,off),XMSundoI,off,hsize);
  1725.    }
  1726. }
  1727.  
  1728.  
  1729. ////////////////////////////////////////////////////
  1730. //
  1731. // Restore Undo buffers
  1732. //
  1733. ////////////////////////////////////////////////////
  1734. void RestoreUndo(void)
  1735. {
  1736.  long size=2L*UndoRegion.w;
  1737.  unsigned j;
  1738.  
  1739.  sound(2000);
  1740.  for (j=UndoRegion.y;j<UndoRegion.y+UndoRegion.h;j++)
  1741.    {
  1742.     unsigned loc=2*(j*mapwidth+UndoRegion.x);
  1743.  
  1744.     if (MapFileHeader->maptype&BPLANE)
  1745.       XMSmove(XMSundoB,loc,0,(long)MK_FP(MapBkgnd,loc),size);
  1746.     if (MapFileHeader->maptype&FPLANE)
  1747.       XMSmove(XMSundoF,loc,0,(long)MK_FP(MapFrgnd,loc),size);
  1748.     if (MapFileHeader->maptype&IPLANE)
  1749.       XMSmove(XMSundoI,loc,0,(long)MK_FP(MapInfoPl,loc),size);
  1750.    }
  1751.  
  1752.  nosound();
  1753. }
  1754.  
  1755.  
  1756. ////////////////////////////////////////////////////
  1757. //
  1758. // Copy the current UNDO region to the undo buffers
  1759. //
  1760. ////////////////////////////////////////////////////
  1761. void CopyUndoRegion(void)
  1762. {
  1763.  if (UndoRegion.x==-1)
  1764.     return;
  1765.  
  1766.  SaveUndo(UndoRegion.x,UndoRegion.y,UndoRegion.w,UndoRegion.h);
  1767. }
  1768.  
  1769.  
  1770. ////////////////////////////////////////////////////
  1771. //
  1772. // Item - Undo
  1773. //
  1774. ////////////////////////////////////////////////////
  1775. void Item_Undo(void)
  1776. {
  1777.  if (UndoRegion.x==-1)
  1778.     {
  1779.      ErrDialog("You don't have anything to UNDO!"," Oh, yeah. ");
  1780.      return;
  1781.     }
  1782.  
  1783.  RestoreUndo();
  1784.  DrawMap();
  1785. }
  1786.  
  1787.  
  1788. ////////////////////////////////////////////////////
  1789. //
  1790. // Item - Tile Search!
  1791. //
  1792. ////////////////////////////////////////////////////
  1793. void Item_TileSearch(void)
  1794. {
  1795.  int num=planeton+planemon+planeion;
  1796.  
  1797.  ZeroModes();
  1798.  if (num>1)
  1799.     {
  1800.      ErrDialog("TILE SEARCH will only work\n"
  1801.             "with ONE active plane! Make\n"
  1802.             "sure that the tile you're\n"
  1803.             "searching for is selected!"," OK ");
  1804.      return;
  1805.     }
  1806.  
  1807.  TsearchMode=1;
  1808.  DrawInfoBar();
  1809.  DrawMap();
  1810. }
  1811.  
  1812. ////////////////////////////////////////////////////
  1813. //
  1814. // Item - Launch
  1815. //
  1816. ////////////////////////////////////////////////////
  1817. char tempparm[40];
  1818.  
  1819. void Item_Launch(void)
  1820. {
  1821.  TempStruct LaunchInfo;
  1822.  char ename[64],*envstr[15],temp[40],temp1[40],temp2[40],tiname[14]="TEDINFO.TMP",i,j;
  1823.  long size;
  1824.  int  rottlaunch;
  1825.  int  startp;
  1826.  unsigned mx,my;
  1827.  
  1828.  
  1829.  rottlaunch=0;
  1830.  if (!TEDInfo->launchname[0])
  1831.     {
  1832.      ErrDialog("You didn't specify a launching\n"
  1833.             "name on the command line? What\n"
  1834.             "do I launch, Einstein? Geez!"," What a goober. ");
  1835.      return;
  1836.     }
  1837.  
  1838.  //
  1839.  // Save the handles for all XMS memory so we don't
  1840.  // have to re-install this shit!
  1841.  //
  1842.  TEDInfo->OldCgaXMS=CgaXMS;
  1843.  TEDInfo->OldEgaXMS=EgaXMS;
  1844.  TEDInfo->OldVgaXMS=VgaXMS;
  1845.  
  1846.  TEDInfo->OldCgaXMSsize=CgaXMSsize;
  1847.  TEDInfo->OldEgaXMSsize=EgaXMSsize;
  1848.  TEDInfo->OldVgaXMSsize=VgaXMSsize;
  1849.  
  1850.  size=4L*(tilenum+tilemnum);
  1851.  if (CgaXMS)
  1852.     {
  1853.      if (1024L*XMSTotalFree()<size)
  1854.         {
  1855.          XMSFreeMem(CgaXMS);
  1856.          TEDInfo->OldCgaXMS=TEDInfo->OldCgaXMSsize=0;
  1857.         }
  1858.      else
  1859.         {
  1860.          TEDInfo->CgaXMSlook=XMSAllocate(size);
  1861.          XMSmove(0,(long)MK_FP(CgaXMSlookup,0),TEDInfo->CgaXMSlook,0,size);
  1862.         }
  1863.     }
  1864.  
  1865.  if (EgaXMS)
  1866.     {
  1867.      if (1024L*XMSTotalFree()<size)
  1868.         {
  1869.          XMSFreeMem(EgaXMS);
  1870.          TEDInfo->OldEgaXMS=TEDInfo->OldEgaXMSsize=0;
  1871.         }
  1872.      else
  1873.         {
  1874.          TEDInfo->EgaXMSlook=XMSAllocate(size);
  1875.          XMSmove(0,(long)MK_FP(EgaXMSlookup,0),TEDInfo->EgaXMSlook,0,size);
  1876.         }
  1877.     }
  1878.  
  1879.  if (VgaXMS)
  1880.     {
  1881.      if (1024L*XMSTotalFree()<size)
  1882.         {
  1883.          XMSFreeMem(VgaXMS);
  1884.          TEDInfo->OldVgaXMS=TEDInfo->OldVgaXMSsize=0;
  1885.         }
  1886.      else
  1887.         {
  1888.          TEDInfo->VgaXMSlook=XMSAllocate(size);
  1889.          XMSmove(0,(long)MK_FP(VgaXMSlookup,0),TEDInfo->VgaXMSlook,0,size);
  1890.         }
  1891.     }
  1892.  
  1893.  //
  1894.  // SAVE CURRENT VIDEOMODE FOR LAUNCH RETURN
  1895.  //
  1896.  LaunchInfo.lastmode=videomode;
  1897.  strcpy(LaunchInfo.ext,ext);
  1898.  SaveFile(tiname,(char huge *)&LaunchInfo,0,sizeof(TempStruct));
  1899.  
  1900.  //
  1901.  // ICON CHANGE ON LAUNCH?
  1902.  //
  1903.  if (keydown[0x2A])
  1904.      {
  1905.      rottlaunch=1;
  1906.      startp=5;
  1907.      mx=xbase+(pixelx>>(tsize+2));
  1908.      my=ybase+((pixely-8)>>(tsize+2));
  1909.      }
  1910.  else
  1911.      startp=3;
  1912.  if (pixely>=8 && pixely<infoy*8 && TEDInfo->permicon
  1913.       && MapFileHeader->maptype&IPLANE && !usingbat && keydown[0x1d])
  1914.     {
  1915.      unsigned i,j;
  1916.  
  1917.      mx=xbase+(pixelx>>(tsize+2));
  1918.      my=ybase+((pixely-8)>>(tsize+2));
  1919.  
  1920.      for (j=0;j<mapheight;j++)
  1921.         for (i=0;i<mapwidth;i++)
  1922.     if (MapInfoPl[j*mapwidth+i]==TEDInfo->permicon)
  1923.       {
  1924.         MapInfoPl[j*mapwidth+i]=0;
  1925.         TEDInfo->lastx=i;
  1926.         TEDInfo->lasty=j;
  1927.         break;
  1928.       }
  1929.  
  1930.      MapInfoPl[my*mapwidth+mx]=TEDInfo->permicon;
  1931.      DrawMap();
  1932.      DirtyFlag=1;
  1933.     }
  1934.  
  1935.  TEDInfo->oscrx=xbase;
  1936.  TEDInfo->oscry=ybase;
  1937.  TEDInfo->pflags=((planeton&1)<<6)|
  1938.          ((planemon&1)<<5)|
  1939.          ((planeion&1)<<4)|
  1940.          ((viewton&1)<<2)|
  1941.          ((viewmon&1)<<1)|
  1942.          (viewion&1);
  1943.  
  1944.  _fmemcpy((void far *)TEDInfo->parmstring,(void far *)parmstring,64);
  1945.  
  1946.  Item_SaveMap();
  1947.  SaveTEDInfo();
  1948.  SaveOutputHeader();
  1949.  
  1950.  if (XMSmaps)
  1951.     XMSFreeMem(XMSmaps);
  1952.  
  1953.  strcpy(temp,"Launching ");
  1954.  _fstrcat((char far *)temp,(char far *)TEDInfo->launchname);
  1955.  strcat(temp,"...");
  1956.  ErrDialog(temp,"");
  1957.  clearkeys();
  1958.  nosound();
  1959.  MouseHide();
  1960.  
  1961.  _fmemcpy((char far *)ename,(char far *)TEDInfo->launchname,14);
  1962.  
  1963.  envstr[0] = ename;
  1964.  envstr[1] = "/TEDLEVEL";
  1965.  itoa(whichmap,temp,10);
  1966.  envstr[2] = temp;
  1967.  if (rottlaunch)
  1968.      {
  1969.      itoa(mx,temp1,10);
  1970.      envstr[3] = temp1;
  1971.      itoa(my,temp2,10);
  1972.      envstr[4] = temp2;
  1973.      }
  1974.  //
  1975.  // CHOP UP THE PARMSTRING FOR 'EXECV'
  1976.  //
  1977.  strcpy(tempparm,parmstring);
  1978.  envstr[startp]=&tempparm[0];
  1979.  for(j=startp+1,i=0;i<strlen(tempparm);i++)
  1980.     if (tempparm[i]==' ')
  1981.     {
  1982.      envstr[j]=&tempparm[i+1];
  1983.      tempparm[i]=0;
  1984.      j++;
  1985.     }
  1986.  envstr[j]=0;
  1987.  
  1988.  RemoveUndoBuffers();
  1989.  ShutdownKBD();
  1990.  
  1991.  //
  1992.  // ARE WE EXITING WITH A BATCH FILE?
  1993.  //
  1994.  
  1995.  if (usingbat)
  1996.     {
  1997.      setvideo(TEXT);
  1998.      exit(whichmap+2);
  1999.    }
  2000.  
  2001.  fcloseall();
  2002.  MMShutdown();
  2003.  execv(ename,envstr);
  2004.  
  2005.  SetupKBD();
  2006.  RestoreBackground();
  2007.  MouseShow();
  2008.  ErrDialog("LAUNCHing failed. TED5 will\n"
  2009.        "now restart."," I have gubs ");
  2010.  ShutdownKBD();
  2011.  execlp("TED5.EXE","TED5.EXE","/LAUNCH",NULL);
  2012.  
  2013.  printf("Couldn't find TED5 for some reason!");
  2014.  exit(1);
  2015. }
  2016.  
  2017.  
  2018. ////////////////////////////////////////////////////
  2019. //
  2020. // Item - TILEINFO Copy
  2021. //
  2022. ////////////////////////////////////////////////////
  2023. DialogDef TICd=
  2024. {"TILEINFOM Copy Kludge\n\n"
  2025.  "From:\n"
  2026.  "  To:\n"
  2027.  "Rows:",22,6};
  2028.  
  2029.  
  2030. void Item_TINFOCopy(void)
  2031. {
  2032.  unsigned dx,dy,i,from,to,amt;
  2033.  memptr block;
  2034.  
  2035.  
  2036.  MouseHide();
  2037.  DrawDialog(&TICd,1);
  2038.  GetDialogXY(&TICd,&dx,&dy);
  2039.  
  2040.  
  2041.  sx=dx+5;
  2042.  sy=dy+2;
  2043.  from=inputint(9);
  2044.  if (from==ESCOUT)
  2045.  {
  2046.   RestoreBackground();
  2047.   MouseShow();
  2048.   return;
  2049.  }
  2050.  
  2051.  
  2052.  sx=dx+5;
  2053.  sy=dy+3;
  2054.  to=inputint(9);
  2055.  if (to==ESCOUT)
  2056.  {
  2057.   RestoreBackground();
  2058.   MouseShow();
  2059.   return;
  2060.  }
  2061.  
  2062.  
  2063.  sx=dx+5;
  2064.  sy=dy+4;
  2065.  amt=inputint(9);
  2066.  if (amt==ESCOUT)
  2067.  {
  2068.   RestoreBackground();
  2069.   MouseShow();
  2070.   return;
  2071.  }
  2072.  amt*=18;
  2073.  
  2074.  
  2075.  MMAllocate(&block,amt);
  2076.  
  2077.  for (i=0;i<numtmplanes;i++)
  2078.  {
  2079.   movedata((unsigned)TMinfo[i],from,(unsigned)block,0,amt);
  2080.   movedata((unsigned)block,0,(unsigned)TMinfo[i],to,amt);
  2081.  }
  2082.  
  2083.  MMFreePtr(&block);
  2084.  RestoreBackground();
  2085.  DirtyFlag=writeH=1;
  2086.  
  2087.  
  2088.  MouseShow();
  2089. }
  2090.